home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / SourceCode / Palettes / PSAction / PSAction.m < prev    next >
Text File  |  1995-06-12  |  7KB  |  324 lines
  1. /* PSAction Object -- copyright 1993, 1994 by C.D.Lane */
  2.  
  3. #import <appkit/appkit.h>
  4. #import <dpsclient/dpsops.h>
  5.  
  6. #import "PSAction.h"
  7. #import "PSActionWrap.h"
  8.  
  9. #define CONTEXT DPSGetCurrentContext()
  10.  
  11. @implementation PSAction
  12.  
  13. - init
  14. {
  15.     contents = NULL;
  16.  
  17.     target = view = script = view = errors = cache = nil;
  18.  
  19.     [[[self setEnabled:YES] setCacheCleared:YES] setErrorReported:YES];
  20.  
  21.     return self;
  22. }
  23.  
  24. - free
  25. {
  26.     if (cache != nil) [cache free];
  27.  
  28.     if (contents != NULL) NX_FREE(contents);
  29.  
  30.     return [super free];
  31. }
  32.  
  33. - (BOOL) isEnabled { return(!flags.disabled); }
  34. - setEnabled:(BOOL) flag { flags.disabled = !flag; return self; }
  35.  
  36. - (BOOL) isCacheCleared { return(!flags.dontClearCache); }
  37. - setCacheCleared:(BOOL) flag { flags.dontClearCache = !flag; return self; }
  38.  
  39. - (BOOL) isErrorReported { return(!flags.dontReportError); }
  40. - setErrorReported:(BOOL) flag { flags.dontReportError = !flag; return self; }
  41.  
  42. - script { return script; }
  43. - setScript:anObject { script = anObject; return self; }
  44.  
  45. - target { return target; }
  46. - setTarget:anObject { target = anObject; return self; }
  47.  
  48. - errors { return errors; }
  49. - setErrors:anObject { errors = anObject; return self; }
  50.  
  51. - view
  52. {
  53.     if (view == nil) {
  54.         NXRect rect = {{0.0, 0.0}, {NX_TOKENWIDTH, NX_TOKENHEIGHT}};
  55.         cache = [[Window alloc] initContent:&rect style:NX_PLAINSTYLE backing:NX_RETAINED buttonMask:0 defer:NO];
  56.         [self setView:[cache contentView]];
  57.         }
  58.  
  59.     return view;
  60. }
  61.  
  62. - setView:anObject
  63. {
  64.     [(view = anObject) getBounds:&bounds];
  65.  
  66.     return self;
  67. }
  68.  
  69. - (int) intValue { return atoi(contents); }
  70. - takeIntValueFrom:sender { return[self setIntValue:[sender intValue]]; }
  71.  
  72. - setIntValue:(int) anInt
  73. {
  74.     if (![self isEnabled]) return self;
  75.  
  76.     [[self view] lockFocus]; {
  77.         DPSsendint(CONTEXT, anInt);
  78.         } [view unlockFocus];
  79.  
  80.     return [self executeScript];
  81. }
  82.  
  83. - integertype
  84. {
  85.     int number;
  86.     char buffer[BUFSIZ];
  87.  
  88.     [[self view] lockFocus]; {
  89.         DPSgetint(CONTEXT, &number);
  90.         } [view unlockFocus];
  91.  
  92.     (void) sprintf(buffer, "%d", number);
  93.  
  94.     if (contents != NULL) NX_FREE(contents);
  95.     contents = NXCopyStringBuffer(buffer);
  96.  
  97.     if (target != nil && [target respondsTo:@selector(takeIntValueFrom:)]) [target takeIntValueFrom:self];
  98.  
  99.     return self;
  100. }
  101.  
  102. - booleantype
  103. {
  104.     int number;
  105.     char buffer[BUFSIZ];
  106.  
  107.     [[self view] lockFocus]; {
  108.         DPSgetboolean(CONTEXT, &number);
  109.         } [view unlockFocus];
  110.  
  111.     (void) sprintf(buffer, "%d", number);
  112.  
  113.     if (contents != NULL) NX_FREE(contents);
  114.     contents = NXCopyStringBuffer(buffer);
  115.  
  116.     if (target != nil && [target respondsTo:@selector(takeIntValueFrom:)]) [target takeIntValueFrom:self];
  117.  
  118.     return self;
  119. }
  120.  
  121. - (float) floatValue { return atof(contents); }
  122. - takeFloatValueFrom:sender { return[self setFloatValue:[sender floatValue]]; }
  123.  
  124. - setFloatValue:(float) aFloat
  125. {
  126.     if (![self isEnabled]) return self;
  127.  
  128.     [[self view] lockFocus]; {
  129.         DPSsendfloat(CONTEXT, aFloat);
  130.         } [view unlockFocus];
  131.  
  132.     return [self executeScript];
  133. }
  134.  
  135. - realtype
  136. {
  137.     float number;
  138.     char buffer[BUFSIZ];
  139.  
  140.     [[self view] lockFocus]; {
  141.         DPSgetfloat(CONTEXT, &number);
  142.         } [view unlockFocus];
  143.  
  144.     (void) sprintf(buffer, "%f", number);
  145.  
  146.     if (contents != NULL) NX_FREE(contents);
  147.     contents = NXCopyStringBuffer(buffer);
  148.  
  149.     if (target != nil && [target respondsTo:@selector(takeFloatValueFrom:)]) [target takeFloatValueFrom:self];
  150.  
  151.     return self;
  152. }
  153.  
  154. - (double) doubleValue { return atof(contents); }
  155. - takeDoubleValueFrom:sender { return[self setDoubleValue:[sender doubleValue]]; }
  156.  
  157. - setDoubleValue:(double) aDouble
  158. {
  159.     if (![self isEnabled]) return self;
  160.  
  161.     [[self view] lockFocus]; {
  162.         DPSsendfloat(CONTEXT, aDouble);
  163.         } [view unlockFocus];
  164.  
  165.     return [self executeScript];
  166. }
  167.  
  168. - (const char *) stringValue { return contents; }
  169. - takeStringValueFrom:sender { return[self setStringValue:[sender stringValue]]; }
  170.  
  171. - setStringValue:(const char *) aString
  172. {
  173.     if (![self isEnabled]) return self;
  174.  
  175.     [[self view] lockFocus]; {
  176.         DPSsendstring(CONTEXT, aString);
  177.         } [view unlockFocus];
  178.  
  179.     return [self executeScript];
  180. }
  181.  
  182. - stringtype
  183. {
  184.     char buffer[BUFSIZ];
  185.  
  186.     [[self view] lockFocus]; {
  187.         DPSgetstring(CONTEXT, buffer);
  188.         } [view unlockFocus];
  189.  
  190.     if (contents != NULL) NX_FREE(contents);
  191.     contents = NXCopyStringBuffer(buffer);
  192.  
  193.     if (target != nil && [target respondsTo:@selector(takeStringValueFrom:)]) [target takeStringValueFrom:self];
  194.  
  195.     return self;
  196. }
  197.  
  198. - nametype
  199. {
  200.     char buffer[BUFSIZ];
  201.  
  202.     [[self view] lockFocus]; {
  203.         DPSgetname(CONTEXT, buffer);
  204.         } [view unlockFocus];
  205.  
  206.     if (contents != NULL) NX_FREE(contents);
  207.     contents = NXCopyStringBuffer(buffer);
  208.  
  209.     if (target != nil && [target respondsTo:@selector(takeStringValueFrom:)]) [target takeStringValueFrom:self];
  210.  
  211.     return self;
  212. }
  213.  
  214. - read:(NXTypedStream *) stream;
  215. {
  216.     [super read:stream];
  217.  
  218.     NXReadType(stream, "{i}", &flags);
  219.  
  220.     return self;
  221. }
  222.  
  223. - write:(NXTypedStream *) stream
  224. {
  225.     [super write:stream];
  226.  
  227.     NXWriteType(stream, "{i}", &flags);
  228.  
  229.     return self;
  230. }
  231.  
  232. - (NXImage *) getIBImage { return([NXImage findImageNamed:"PSActionPalette"]); }
  233.  
  234. - (const char *) getInspectorClassName { return "PSActionInspector"; }
  235.  
  236. - printf:(const char *) format, ...
  237. {
  238.     int length;
  239.     va_list    ap;
  240.     char buffer[BUFSIZ];
  241.  
  242.     if (![self isErrorReported]) return nil;
  243.  
  244.     va_start(ap, format); {
  245.         if (errors == nil) (void) vfprintf(stderr, format, ap);
  246.         else {
  247.             (void) vsprintf(buffer, format, ap);
  248.             length = [errors textLength];
  249.             [[[[errors setSel:length :length] replaceSel:buffer] scrollSelToVisible] display];
  250.             }
  251.         } va_end(ap);
  252.  
  253.     return nil; /* return nil so it can be used as an error return */
  254. }
  255.  
  256. - scriptError:(NXHandler *) error
  257. {
  258.     char *address;
  259.     NXStream *stream;
  260.     int length, maximum;
  261.  
  262.     if (error->code == dps_err_ps) {
  263.         if ((stream = NXOpenMemory(NULL, 0, NX_WRITEONLY)) != NULL) {
  264.             DPSPrintErrorToStream(stream, (DPSBinObjSeq) (error->data2));
  265.             NXFlush(stream);
  266.             NXGetMemoryBuffer(stream, &address, &length, &maximum);
  267.             [self printf:address];
  268.             NXCloseMemory(stream, NX_FREEBUFFER);
  269.             }
  270.         else [self printf:"Unable to open memory stream to process PostScript error code.\n"];
  271.         }
  272.     else [self printf:"Unknown PostScript error occured.\n"];
  273.  
  274.     return self;
  275. }
  276.  
  277. - executeScript
  278. {
  279.     SEL action;
  280.     NXHandler error;
  281.     NXStream *stream;
  282.     int length, maximum;
  283.     char *address, buffer[BUFSIZ];
  284.     float gray = [[[self view] window] backgroundGray];
  285.  
  286.     if ((stream = NXOpenMemory(NULL, 0, NX_WRITEONLY)) == NULL) return [self printf:"NXOpenMemory() error.\n"];
  287.  
  288.     if (script != nil) {
  289.         if ([script isKindOf:[Control class]]) NXPrintf(stream, "%s\n", [script stringValue]);
  290.         else if ([script isKindOf:[Text class]]) [script writeText:stream];
  291.         }
  292.  
  293.     NXPrintf(stream, "\n");
  294.     NXFlush(stream);
  295.  
  296.     NXGetMemoryBuffer(stream, &address, &length, &maximum);
  297.  
  298.     error.code = 0;
  299.  
  300.     saveState(CONTEXT); {
  301.         [[self view] lockFocus]; {
  302.             if ([self isCacheCleared]) eraseRect(CONTEXT, gray);
  303.             NX_DURING {
  304.                 DPSWriteData(CONTEXT, address, length);
  305.                 getType(CONTEXT, buffer);
  306.                 } NX_HANDLER {
  307.                     error = NXLocalHandler;
  308.                     } NX_ENDHANDLER
  309.             } [view unlockFocus];
  310.  
  311.         if (error.code != 0) [self scriptError:&error];
  312.         else {
  313.             action = sel_getUid(buffer);
  314.             if ([self respondsTo:action]) [self perform:action];
  315.             else [self printf:"Can't handle PostScript type \"%s\"!\n", buffer];
  316.             }
  317.         } restoreState(CONTEXT);
  318.  
  319.       NXCloseMemory(stream, NX_FREEBUFFER);
  320.  
  321.     return self;
  322. }
  323.  
  324. @end